home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Essentials / Developer Essentials Jul 90 / Programming / MPW Interfaces & Libraries 3.1 / PInterfaces / Script.p < prev    next >
Encoding:
Text File  |  1989-10-13  |  25.1 KB  |  870 lines  |  [TEXT/MPS ]
  1. {
  2. Created: Tuesday, September 12, 1989 at 6:11 PM
  3.     Script.p
  4.     Pascal Interface to the Macintosh Libraries
  5.  
  6.     Copyright Apple Computer, Inc.    1986-1989
  7.     All rights reserved
  8. }
  9.  
  10.  
  11. {$IFC UNDEFINED UsingIncludes}
  12. {$SETC UsingIncludes := 0}
  13. {$ENDC}
  14.  
  15. {$IFC NOT UsingIncludes}
  16.     UNIT Script;
  17.     INTERFACE
  18. {$ENDC}
  19.  
  20. {$IFC UNDEFINED UsingScript}
  21. {$SETC UsingScript := 1}
  22.  
  23. {$I+}
  24. {$SETC ScriptIncludes := UsingIncludes}
  25. {$SETC UsingIncludes := 1}
  26. {$IFC UNDEFINED UsingTypes}
  27. {$I $$Shell(PInterfaces)Types.p}
  28. {$ENDC}
  29. {$IFC UNDEFINED UsingPackages}
  30. {$I $$Shell(PInterfaces)Packages.p}
  31. {$ENDC}
  32. {$SETC UsingIncludes := ScriptIncludes}
  33.  
  34. CONST
  35.  
  36. { Note that the version number is divided into two bytes:  The high byte is
  37. bumped when the changes make the next version incompatible with previous
  38. versions.  If compatability is maintained, the low byte is bumped. The low
  39. byte is maintained privately by the Script Manager, and is shown as 0 here. }
  40.  
  41. smgrVers = $0200;                                    {current version number.}
  42.  
  43. { Script Interface System Numbers }
  44.  
  45. smRoman = 0;                                        {Font script is Roman.}
  46. smJapanese = 1;                                     {Font script is Japanese.}
  47. smChinese = 2;                                        {Font script is Chinese.}
  48. smKorean = 3;                                        {Font script is Korean.}
  49. smArabic = 4;                                        {Font script is Arabic.}
  50. smHebrew = 5;                                        {Font script is Hebrew.}
  51. smGreek = 6;                                        {Font script is Greek.}
  52. smRussian = 7;                                        {Font script is Russian.}
  53. smRSymbol = 8;                                        {Font script is Right-left symbol.}
  54. smDevanagari = 9;                                    {Font script is Devanagari.}
  55. smGurmukhi = 10;                                    {Font script is Gurmukhi.}
  56. smGujarati = 11;                                    {Font script is Gujarati.}
  57. smOriya = 12;                                        {Font script is Oriya.}
  58. smBengali = 13;                                     {Font script is Bengali.}
  59. smTamil = 14;                                        {Font script is Tamil.}
  60. smTelugu = 15;                                        {Font script is Telugu.}
  61. smKannada = 16;                                     {Font script is Kannada.}
  62. smMalayalam = 17;                                    {Font script is Malayalam.}
  63. smSinhalese = 18;                                    {Font script is Sinhalese.}
  64. smBurmese = 19;                                     {Font script is Burmese.}
  65. smKhmer = 20;                                        {Font script is Khmer.}
  66. smThai = 21;                                        {Font script is Thai.}
  67. smLaotian = 22;                                     {Font script is Laotian.}
  68. smGeorgian = 23;                                    {Font script is Georgian.}
  69. smArmenian = 24;                                    {Font script is Armenian.}
  70. smMaldivian = 25;                                    {Font script is Maldivian.}
  71. smTibetan = 26;                                     {Font script is Tibetan.}
  72. smMongolian = 27;                                    {Font script is Mongolian.}
  73. smAmharic = 28;                                     {Font script is Amharic.}
  74. smGeez = 28;                                        {Font script is Amharic.}
  75. smSlavic = 29;                                        {Font script is Slavic.}
  76. smVietnamese = 30;                                    {Font script is Vietnamese.}
  77. smSindhi = 31;                                        {Font script is Sindhi.}
  78. smUninterp = 32;                                    {Font script is uninterpreted symbols.}
  79.  
  80. { Language Codes }
  81.  
  82. langEnglish = 0;
  83. langFrench = 1;
  84. langGerman = 2;
  85. langItalian = 3;
  86. langDutch = 4;
  87. langSwedish = 5;
  88. langSpanish = 6;
  89. langDanish = 7;
  90. langPortugese = 8;
  91. langNorwegian = 9;
  92. langHebrew = 10;
  93. langJapanese = 11;
  94. langArabic = 12;
  95. langFinnish = 13;
  96. langGreek = 14;
  97. langIcelandic = 15;
  98. langMalta = 16;
  99. langTurkish = 17;
  100. langYugoslavian = 18;
  101. langChinese = 19;
  102. langUrdu = 20;
  103. langHindi = 21;
  104. langThai = 22;
  105.  
  106. { Calendar Codes }
  107.  
  108. calGregorian = 0;
  109. calArabicCivil = 1;
  110. calArabicLunar = 2;
  111. calJapanese = 3;
  112. calJewish = 4;
  113. calCoptic = 5;
  114.  
  115. { Integer Format Codes }
  116.  
  117. intWestern = 0;
  118. intArabic = 1;
  119. intRoman = 2;
  120. intJapanese = 3;
  121. intEuropean = 4;
  122. intOutputMask = $8000;
  123.  
  124. { CharByte byte types }
  125.  
  126. smSingleByte = 0;
  127. smFirstByte = -1;
  128. smLastByte = 1;
  129. smMiddleByte = 2;
  130.  
  131. { CharType field masks }
  132.  
  133. smcTypeMask = $000F;
  134. smcReserved = $00F0;
  135. smcClassMask = $0F00;
  136. smcReserved12 = $1000;
  137. smcRightMask = $2000;
  138. smcUpperMask = $4000;
  139. smcDoubleMask = $8000;
  140.  
  141. { CharType character types }
  142.  
  143. smCharPunct = 0;
  144. smCharAscii = 1;
  145. smCharEuro = 7;
  146.  
  147. { additional CharType character types for FIS character sets }
  148.  
  149. smCharFISKana = 2;                                    {Katakana}
  150. smCharFISGana = 3;                                    {Hiragana}
  151. smCharFISIdeo = 4;                                    {Hanzi, Kanji, Hanja}
  152. smCharFISGreek = 5;                                 {Greek (2-byte)}
  153. smCharFISRussian = 6;                                {Russian/Cyrillic (2-byte)}
  154. smCharFISHangul = 8;                                {Hangul (**tentative**)}
  155.  
  156. { CharType classes (smCharPunct sub-types) }
  157.  
  158. smPunctNormal = $0000;
  159. smPunctNumber = $0100;
  160. smPunctSymbol = $0200;
  161. smPunctBlank = $0300;
  162.  
  163. { additional CharType classes for FIS (smCharFISIdeo sub-types) }
  164.  
  165. smFISClassLvl1 = $0000;                             {level 1 char}
  166. smFISClassLvl2 = $0100;                             {level 2 char}
  167. smFISClassUser = $0200;                             {user char}
  168.  
  169. { CharType directions }
  170.  
  171. smCharLeft = $0000;
  172. smCharRight = $2000;
  173.  
  174. { CharType case modifers }
  175.  
  176. smCharLower = $0000;
  177. smCharUpper = $4000;
  178.  
  179. { CharType character size modifiers (1 or multiple bytes). }
  180.  
  181. smChar1byte = $0000;
  182. smChar2byte = $8000;
  183.  
  184. { Char2Pixel directions }
  185.  
  186. smLeftCaret = 0;                                    {Place caret for left block.}
  187. smRightCaret = -1;                                    {Place caret for right block.}
  188. smHilite = 1;                                        {Direction is TESysJust.}
  189.  
  190. { Transliterate target types }
  191.  
  192. smTransAscii = 0;
  193. smTransNative = 1;
  194. smTransCase = $FE;
  195. smTransSystem = $FF;                                {convert to system script}
  196.  
  197. { Transliterate target types for FIS }
  198.  
  199. smTransAscii1 = 2;                                    {1-byte Roman}
  200. smTransAscii2 = 3;                                    {2-byte Roman}
  201. smTransKana1 = 4;                                    {1-byte Katakana}
  202. smTransKana2 = 5;                                    {2-byte Katakana}
  203. smTransGana2 = 7;                                    {2-byte Hiragana (no 1-byte Hiragana)}
  204.  
  205. { Transliterate target modifiers }
  206.  
  207. smTransLower = $4000;
  208. smTransUpper = $8000;
  209.  
  210. { Transliterate source mask - general }
  211.  
  212. smMaskAll = $FFFFFFFF;                                {Convert all text}
  213.  
  214. { Transliterate source masks }
  215.  
  216. smMaskAscii = $00000001;                            {2^smTransAscii}
  217. smMaskNative = $00000002;                            {2^smTransNative}
  218.  
  219. { Transliterate source masks for FIS }
  220.  
  221. smMaskAscii1 = $00000004;                            {2^smTransAscii1}
  222. smMaskAscii2 = $00000008;                            {2^smTransAscii2}
  223. smMaskKana1 = $00000010;                            {2^smTransKana1}
  224. smMaskKana2 = $00000020;                            {2^smTransKana2}
  225. smMaskGana2 = $00000080;                            {2^smTransGana2}
  226.  
  227. { Result values from GetEnvirons, SetEnvirons, GetScript and SetScript calls. }
  228.  
  229. smNotInstalled = 0;                                 {routine not available in script}
  230. smBadVerb = -1;                                     {Bad verb passed to a routine.}
  231. smBadScript = -2;                                    {Bad script code passed to a routine.}
  232.  
  233. { GetEnvirons and SetEnvirons verbs }
  234.  
  235. smVersion = 0;                                        {Environment version number.}
  236. smMunged = 2;                                        {Globals change count.}
  237. smEnabled = 4;                                        {Environment enabled flag.}
  238. smBidirect = 6;                                     {At least on bidirect script.}
  239. smFontForce = 8;                                    {Force font flag.}
  240. smIntlForce = 10;                                    {Force intl flag.}
  241. smForced = 12;                                        {script forced to system script.}
  242. smDefault = 14;                                     {script defaulted to Roman script.}
  243. smPrint = 16;                                        {Printer action routine.}
  244. smSysScript = 18;                                    {System script.}
  245. smLastScript = 20;                                    {Last keyboard script.}
  246. smKeyScript = 22;                                    {Keyboard script.}
  247. smSysRef = 24;                                        {System folder refNum.}
  248. smKeyCache = 26;                                    {Keyboard table cache pointer.}
  249. smKeySwap = 28;                                     {Swapping table pointer.}
  250. smGenFlags = 30;                                    {General flags long}
  251. smOverride = 32;                                    {Script override flags.}
  252. smCharPortion = 34;                                 {Ch vs SpExtra proportion}
  253. smLastEVerb = smCharPortion;                        {Last environment verb.}
  254.  
  255. { GetScript and SetScript verbs.
  256. Note: Verbs private to script systems are negative, while
  257. those general across script systems are non-negative. }
  258.  
  259. smScriptVersion = 0;                                {Script software version.}
  260. smScriptMunged = 2;                                 {Script entry changed count.}
  261. smScriptEnabled = 4;                                {Script enabled flag.}
  262. smScriptRight = 6;                                    {Right to left flag.}
  263. smScriptJust = 8;                                    {Justification flag.}
  264. smScriptRedraw = 10;                                {Word redraw flag.}
  265. smScriptSysFond = 12;                                {Preferred system font.}
  266. smScriptAppFond = 14;                                {Preferred Application font.}
  267. smScriptBundle = 16;                                {Beginning of dictionary verbs.}
  268. smScriptNumber = 16;                                {Script itl0 id from dictionary.}
  269. smScriptDate = 18;                                    {Script itl1 id from dictionary.}
  270. smScriptSort = 20;                                    {Script itl2 id from dictionary.}
  271. smScriptFlags = 22;                                 {flags word.}
  272. smScriptToken = 24;                                 {Script itl3 id, from dictionary.}
  273. smScriptRsvd3 = 26;                                 {reserved.}
  274. smScriptLang = 28;                                    {Current language for script.}
  275. smScriptNumDate = 30;                                {Script Number/Date formats.}
  276. smScriptKeys = 32;                                    {Script KEYC id from dictionary.}
  277. smScriptIcon = 34;                                    {Script SICN id from dictionary.}
  278. smScriptPrint = 36;                                 {Script printer action routine.}
  279. smScriptTrap = 38;                                    {Trap entry pointer.}
  280. smScriptCreator = 40;                                {Script file creator.}
  281. smScriptFile = 42;                                    {Script file name.}
  282. smScriptName = 44;                                    {Script name.}
  283. smLastSVerb = smScriptName;                         {Last script verb.}
  284.  
  285. { Bits in the smScriptFlags word
  286. (bits above 7 are non-static) }
  287.  
  288. smsfIntellCP = 0;                                    {script has intellegent cut & paste}
  289. smsfSingByte = 1;                                    {script has only single bytes}
  290. smsfNatCase = 2;                                    {native chars have upper & lower case}
  291. smsfContext = 3;                                    {contextual script (e.g. AIS-based)}
  292. smsfNoForceFont = 4;                                {Will not force characters.}
  293. smsfB0Digits = 5;                                    {Has alternate digits at B0-B9.}
  294. smsfForms = 13;                                     {Uses contextual forms for letters.}
  295. smsfLigatures = 14;                                 {Uses contextual ligatures.}
  296. smsfReverse = 15;                                    {Reverses native text, right-left.}
  297.  
  298. { Bits in the smGenFlags long.
  299. First byte is set from itlc flags byte. }
  300.  
  301. smfShowIcon = 31;                                    {Show icon even if only one script.}
  302. smfDualCaret = 30;                                    {Use dual caret for mixed direction text.}
  303.  
  304. { Roman script constants }
  305.  
  306. romanVers = $0101;                                    {version number}
  307. romanSysFond = $3FFF;                                {system font id number}
  308. romanAppFond = 3;                                    {application font id number.}
  309. romanFlags = $0007;                                 {roman settings}
  310.  
  311. { Script Manager font equates. }
  312.  
  313. smFondStart = $4000;                                {start from 16K.}
  314. smFondEnd = $C000;                                    {past end of range at 48K.}
  315.  
  316. { Character Set Extensions }
  317.  
  318. diaeresisUprY = $D9;
  319. fraction = $DA;
  320. intlCurrency = $DB;
  321. leftSingGuillemet = $DC;
  322. rightSingGuillemet = $DD;
  323. fiLigature = $DE;
  324. flLigature = $DF;
  325. dblDagger = $E0;
  326. centeredDot = $E1;
  327. baseSingQuote = $E2;
  328. baseDblQuote = $E3;
  329. perThousand = $E4;
  330. circumflexUprA = $E5;
  331. circumflexUprE = $E6;
  332. acuteUprA = $E7;
  333. diaeresisUprE = $E8;
  334. graveUprE = $E9;
  335. acuteUprI = $EA;
  336. circumflexUprI = $EB;
  337. diaeresisUprI = $EC;
  338. graveUprI = $ED;
  339. acuteUprO = $EE;
  340. circumflexUprO = $EF;
  341. appleLogo = $F0;
  342. graveUprO = $F1;
  343. acuteUprU = $F2;
  344. circumflexUprU = $F3;
  345. graveUprU = $F4;
  346. dotlessLwrI = $F5;
  347. circumflex = $F6;
  348. tilde = $F7;
  349. macron = $F8;
  350. breve = $F9;
  351. overDot = $FA;
  352. ring = $FB;
  353. cedilla = $FC;
  354. doubleAcute = $FD;
  355. ogonek = $FE;
  356. hachek = $FF;
  357.  
  358. { String2Date status values }
  359.  
  360. fatalDateTime = $8000;
  361. longDateFound = 1;
  362. leftOverChars = 2;
  363. sepNotIntlSep = 4;
  364. fieldOrderNotIntl = 8;
  365. extraneousStrings = 16;
  366. tooManySeps = 32;
  367. sepNotConsistent = 64;
  368. tokenErr = $8100;
  369. cantReadUtilities = $8200;
  370. dateTimeNotFound = $8400;
  371. dateTimeInvalid = $8800;
  372.  
  373. { TokenType values }
  374.  
  375. tokenIntl = 4;                                        {the itl resource number of the tokenizer}
  376. tokenEmpty = -1;
  377. tokenUnknown = 0;
  378. tokenWhite = 1;
  379. tokenLeftLit = 2;
  380. tokenRightLit = 3;
  381. tokenAlpha = 4;
  382. tokenNumeric = 5;
  383. tokenNewLine = 6;
  384. tokenLeftComment = 7;
  385. tokenRightComment = 8;
  386. tokenLiteral = 9;
  387. tokenEscape = 10;
  388. tokenAltNum = 11;
  389. tokenRealNum = 12;
  390. tokenAltReal = 13;
  391. tokenReserve1 = 14;
  392. tokenReserve2 = 15;
  393. tokenLeftParen = 16;
  394. tokenRightParen = 17;
  395. tokenLeftBracket = 18;
  396. tokenRightBracket = 19;
  397. tokenLeftCurly = 20;
  398. tokenRightCurly = 21;
  399. tokenLeftEnclose = 22;
  400. tokenRightEnclose = 23;
  401. tokenPlus = 24;
  402. tokenMinus = 25;
  403. tokenAsterisk = 26;
  404. tokenDivide = 27;
  405. tokenPlusMinus = 28;
  406. tokenSlash = 29;
  407. tokenBackSlash = 30;
  408. tokenLess = 31;
  409. tokenGreat = 32;
  410. tokenEqual = 33;
  411. tokenLessEqual2 = 34;
  412. tokenLessEqual1 = 35;
  413. tokenGreatEqual2 = 36;
  414. tokenGreatEqual1 = 37;
  415. token2Equal = 38;
  416. tokenColonEqual = 39;
  417. tokenNotEqual = 40;
  418. tokenLessGreat = 41;
  419. tokenExclamEqual = 42;
  420. tokenExclam = 43;
  421. tokenTilda = 44;
  422. tokenComma = 45;
  423. tokenPeriod = 46;
  424. tokenLeft2Quote = 47;
  425. tokenRight2Quote = 48;
  426. tokenLeft1Quote = 49;
  427. tokenRight1Quote = 50;
  428. token2Quote = 51;
  429. token1Quote = 52;
  430. tokenSemicolon = 53;
  431. tokenPercent = 54;
  432. tokenCarat = 55;
  433. tokenUnderline = 56;
  434. tokenAmpersand = 57;
  435. tokenAtSign = 58;
  436. tokenBar = 59;
  437. tokenQuestion = 60;
  438. tokenPi = 61;
  439. tokenRoot = 62;
  440. tokenSigma = 63;
  441. tokenIntegral = 64;
  442. tokenMicro = 65;
  443. tokenCapPi = 66;
  444. tokenInfinity = 67;
  445. tokenColon = 68;
  446. tokenHash = 69;
  447. tokenDollar = 70;
  448. tokenNoBreakSpace = 71;
  449. tokenFraction = 72;
  450. tokenIntlCurrency = 73;
  451. tokenLeftSingGuillemet = 74;
  452. tokenRightSingGuillemet = 75;
  453. tokenPerThousand = 76;
  454. tokenNil = 127;
  455. delimPad = -2;
  456.  
  457. { the NumberParts indeces }
  458.  
  459. tokLeftQuote = 1;
  460. tokRightQuote = 2;
  461. tokLeadPlacer = 3;
  462. tokLeader = 4;
  463. tokNonLeader = 5;
  464. tokZeroLead = 6;
  465. tokPercent = 7;
  466. tokPlusSign = 8;
  467. tokMinusSign = 9;
  468. tokThousands = 10;
  469. tokSeparator = 12;                                    {11 is a reserved field}
  470. tokEscape = 13;
  471. tokDecPoint = 14;
  472. tokEPlus = 15;
  473. tokEMinus = 16;
  474. tokMaxSymbols = 31;
  475. curNumberPartsVersion = 1;                            {current version of NumberParts record}
  476.  
  477. {  Date equates }
  478.  
  479. smallDateBit = 31;                                    {Restrict valid date/time to range of Time global}
  480. togChar12HourBit = 30;                                {If toggling hour by char, accept hours 1..12 only}
  481. togCharZCycleBit = 29;                                {Modifier for togChar12HourBit: accept hours 0..11 only}
  482. togDelta12HourBit = 28;                             {If toggling hour up/down, restrict to 12-hour range (am/pm)}
  483. genCdevRangeBit = 27;                                {Restrict date/time to range used by genl CDEV}
  484. validDateFields = -1;
  485. maxDateField = 10;
  486. eraMask = $0001;
  487. yearMask = $0002;
  488. monthMask = $0004;
  489. dayMask = $0008;
  490. hourMask = $0010;
  491. minuteMask = $0020;
  492. secondMask = $0040;
  493. dayOfWeekMask = $0080;
  494. dayOfYearMask = $0100;
  495. weekOfYearMask = $0200;
  496. pmMask = $0400;
  497. dateStdMask = $007F;
  498. fVNumber = 0;                                        {first version of NumFormatString}
  499.  
  500. { Toggle results }
  501.  
  502. toggleUndefined = 0;
  503. toggleOK = 1;
  504. toggleBadField = 2;
  505. toggleBadDelta = 3;
  506. toggleBadChar = 4;
  507. toggleUnknown = 5;
  508. toggleBadNum = 6;
  509. toggleOutOfRange = 7;                                {synonym for toggleErr3}
  510. toggleErr3 = 7;
  511. toggleErr4 = 8;
  512. toggleErr5 = 9;
  513.  
  514.  
  515. TYPE
  516.  
  517. TokenResults = (tokenOK,tokenOverflow,stringOverflow,badDelim,badEnding,
  518.     crash);
  519.  
  520. LongDateField = (eraField,yearField,monthField,dayField,hourField,minuteField,
  521.     secondField,dayOfWeekField,dayOfYearField,weekOfYearField,pmField,res1Field,
  522.     res2Field,res3Field);
  523.  
  524. StyledLineBreakCode = (smBreakWord,smBreakChar,smBreakOverflow);
  525.  
  526. FormatClass = (fPositive,fNegative,fZero);
  527.  
  528. FormatResultType = (fFormatOK,fBestGuess,fOutOfSynch,fSpuriousChars,fMissingDelimiter,
  529.     fExtraDecimal,fMissingLiteral,fExtraExp,fFormatOverflow,fFormStrIsNAN,
  530.     fBadPartsTable,fExtraPercent,fExtraSeparator,fEmptyFormatString);
  531.  
  532.  
  533. CharByteTable = PACKED ARRAY [0..255] OF SignedByte;
  534.  
  535. BreakTablePtr = ^BreakTable;
  536. BreakTable = RECORD
  537.     charTypes: ARRAY [0..255] OF SignedByte;
  538.     tripleLength: INTEGER;
  539.     triples: ARRAY [0..0] OF INTEGER;
  540.     END;
  541.  
  542. OffPair = RECORD
  543.     offFirst: INTEGER;
  544.     offSecond: INTEGER;
  545.     END;
  546.  
  547. OffsetTable = ARRAY [0..2] of OffPair;
  548.  
  549. ItlcRecord = RECORD
  550.     itlcSystem: INTEGER;                            {default system script.}
  551.     itlcReserved: INTEGER;                            {reserved}
  552.     itlcFontForce: SignedByte;                        {default font force flag}
  553.     itlcIntlForce: SignedByte;                        {default intl force flag.}
  554.     itlcOldKybd: SignedByte;                        {old keyboard}
  555.     itlcFlags: SignedByte;                            {general flags}
  556.     itlcIconOffset: INTEGER;                        {script icon offset}
  557.     itlcIconSide: SignedByte;                        {icon side}
  558.     itlcIconRsvd: SignedByte;                        {rsvd for other icon info}
  559.     itlcReserved2: ARRAY [0..35] OF SignedByte;     {for future use}
  560.     END;
  561.  
  562. ItlbRecord = RECORD
  563.     itlbNumber: INTEGER;                            {ITL0 id number.}
  564.     itlbDate: INTEGER;                                {ITL1 id number.}
  565.     itlbSort: INTEGER;                                {ITL2 id number.}
  566.     itlbFlags: INTEGER;                             {Script flags}
  567.     itlbToken: INTEGER;                             {ITL4 id number.}
  568.     itlbReserved3: INTEGER;                         {reserved.}
  569.     itlbLang: INTEGER;                                {cur language for script }
  570.     itlbNumRep: SignedByte;                         {number representation code}
  571.     itlbDateRep: SignedByte;                        {date representation code }
  572.     itlbKeys: INTEGER;                                {KCHR id number.}
  573.     itlbIcon: INTEGER;                                {SICN id number.}
  574.     END;
  575.  
  576. MachineLocation = RECORD
  577.     latitude: Fract;
  578.     longitude: Fract;
  579.     CASE INTEGER OF
  580.       0:
  581.         (dlsDelta: SignedByte);                     {signed byte; daylight savings delta}
  582.       1:
  583.         (gmtDelta: LONGINT);                        {must mask - see documentation}
  584.     END;
  585.  
  586. String2DateStatus = INTEGER;
  587.  
  588. TokenType = INTEGER;
  589.  
  590. DelimType = ARRAY [0..1] OF TokenType;
  591.  
  592. CommentType = ARRAY [0..3] OF TokenType;
  593.  
  594. TokenRecPtr = ^TokenRec;
  595. TokenRec = RECORD
  596.     theToken: TokenType;
  597.     position: Ptr;                                    {pointer into original Source}
  598.     length: LONGINT;                                {length of text in original source}
  599.     stringPosition: StringPtr;                        {Pascal/C string copy of identifier}
  600.     END;
  601.  
  602. TokenBlockPtr = ^TokenBlock;
  603. TokenBlock = RECORD
  604.     source: Ptr;                                    {pointer to stream of characters}
  605.     sourceLength: LONGINT;                            {length of source stream}
  606.     tokenList: Ptr;                                 {pointer to array of tokens}
  607.     tokenLength: LONGINT;                            {maximum length of TokenList}
  608.     tokenCount: LONGINT;                            {number tokens generated by tokenizer}
  609.     stringList: Ptr;                                {pointer to stream of identifiers}
  610.     stringLength: LONGINT;                            {length of string list}
  611.     stringCount: LONGINT;                            {number of bytes currently used}
  612.     doString: BOOLEAN;                                {make strings & put into StringLIst}
  613.     doAppend: BOOLEAN;                                {append to TokenList rather than replace}
  614.     doAlphanumeric: BOOLEAN;                        {identifiers may include numeric}
  615.     doNest: BOOLEAN;                                {do comments nest?}
  616.     leftDelims: ARRAY [0..1] OF TokenType;
  617.     rightDelims: ARRAY [0..1] OF TokenType;
  618.     leftComment: ARRAY [0..3] OF TokenType;
  619.     rightComment: ARRAY [0..3] OF TokenType;
  620.     escapeCode: TokenType;                            {escape symbol code}
  621.     decimalCode: TokenType;
  622.     itlResource: Handle;                            {ptr to itl4 resource of current script}
  623.     reserved: ARRAY [0..7] OF LONGINT;                {must be zero!}
  624.     END;
  625.  
  626. UntokenTablePtr = ^UntokenTable;
  627. UntokenTableHandle = ^UntokenTablePtr;
  628. UntokenTable = RECORD
  629.     len: INTEGER;
  630.     lastToken: INTEGER;
  631.     index: ARRAY [0..255] OF INTEGER;                {index table; last = lastToken}
  632.     END;
  633.  
  634. DateCachePtr = ^DateCacheRecord;
  635. DateCacheRecord = PACKED RECORD
  636.     hidden: ARRAY [0..255] OF INTEGER;                {only for temporary use}
  637.     END;
  638.  
  639. LongDateTime = Comp;
  640.  
  641. LongDateCvt = RECORD
  642.     CASE INTEGER OF
  643.       0:
  644.         (c: Comp);
  645.       1:
  646.         (lHigh: LONGINT;
  647.         lLow: LONGINT);
  648.     END;
  649.  
  650. LongDateRec = RECORD
  651.     CASE INTEGER OF
  652.       0:
  653.         (era: INTEGER;
  654.         year: INTEGER;
  655.         month: INTEGER;
  656.         day: INTEGER;
  657.         hour: INTEGER;
  658.         minute: INTEGER;
  659.         second: INTEGER;
  660.         dayOfWeek: INTEGER;
  661.         dayOfYear: INTEGER;
  662.         weekOfYear: INTEGER;
  663.         pm: INTEGER;
  664.         res1: INTEGER;
  665.         res2: INTEGER;
  666.         res3: INTEGER);
  667.       1:
  668.         (list: ARRAY [0..13] OF INTEGER);            {Index by LongDateField!}
  669.       2:
  670.         (eraAlt: INTEGER;
  671.         oldDate: DateTimeRec);
  672.     END;
  673.  
  674. DateDelta = SignedByte;
  675.  
  676. TogglePB = RECORD
  677.     togFlags: LONGINT;                                {caller normally sets low word to dateStdMask=$7F}
  678.     amChars: ResType;                                {from intl0}
  679.     pmChars: ResType;                                {from intl0}
  680.     reserved: ARRAY [0..3] OF LONGINT;
  681.     END;
  682.  
  683. FormatOrderPtr = ^FormatOrder;
  684. FormatOrder = ARRAY [0..0] OF INTEGER;
  685.  
  686. FormatStatus = INTEGER;
  687.  
  688. WideChar = RECORD
  689.     CASE BOOLEAN OF
  690.       TRUE:
  691.         (a: PACKED ARRAY [0..1] OF CHAR);            {0 is the high order character}
  692.       FALSE:
  693.         (b: INTEGER);
  694.     END;
  695.  
  696. WideCharArr = RECORD
  697.     size: INTEGER;
  698.     data: PACKED ARRAY [0..9] OF WideChar;
  699.     END;
  700.  
  701. NumFormatString = PACKED RECORD
  702.     fLength: Byte;
  703.     fVersion: Byte;
  704.     data: PACKED ARRAY [0..253] OF SignedByte;        {private data}
  705.     END;
  706.  
  707. Itl4Ptr = ^Itl4Rec;
  708. Itl4Handle = ^Itl4Ptr;
  709. Itl4Rec = RECORD
  710.     flags: INTEGER;
  711.     resourceType: LONGINT;
  712.     resourceNum: INTEGER;
  713.     version: INTEGER;
  714.     resHeader1: LONGINT;
  715.     resHeader2: LONGINT;
  716.     numTables: INTEGER;                             {one-based}
  717.     mapOffset: LONGINT;                             {offsets are from record start}
  718.     strOffset: LONGINT;
  719.     fetchOffset: LONGINT;
  720.     unTokenOffset: LONGINT;
  721.     defPartsOffset: LONGINT;
  722.     resOffset6: LONGINT;
  723.     resOffset7: LONGINT;
  724.     resOffset8: LONGINT;
  725.     END;
  726.  
  727. NumberPartsPtr = ^NumberParts;
  728. NumberParts = RECORD
  729.     version: INTEGER;
  730.     data: ARRAY [1..31] OF WideChar;                {index by [tokLeftQuote..tokMaxSymbols]}
  731.     pePlus: WideCharArr;
  732.     peMinus: WideCharArr;
  733.     peMinusPlus: WideCharArr;
  734.     altNumTable: WideCharArr;
  735.     reserved: PACKED ARRAY [0..19] OF CHAR;
  736.     END;
  737.  
  738. FVector = RECORD
  739.     start: INTEGER;
  740.     length: INTEGER;
  741.     END;
  742.  
  743. TripleInt = ARRAY [0..2] OF FVector;                { index by [fPositive..fZero] }
  744.  
  745. ScriptRunStatus = RECORD
  746.     script: SignedByte;
  747.     variant: SignedByte;
  748.     END;
  749.  
  750. ToggleResults = INTEGER;
  751.  
  752.  
  753.  
  754. FUNCTION FontScript: INTEGER;
  755.     INLINE $2F3C,$8200,$0000,$A8B5;
  756. FUNCTION IntlScript: INTEGER;
  757.     INLINE $2F3C,$8200,$0002,$A8B5;
  758. PROCEDURE KeyScript(code: INTEGER);
  759.     INLINE $2F3C,$8002,$0004,$A8B5;
  760. FUNCTION Font2Script(fontNumber: INTEGER): INTEGER;
  761.     INLINE $2F3C,$8202,$0006,$A8B5;
  762. FUNCTION GetEnvirons(verb: INTEGER): LONGINT;
  763.     INLINE $2F3C,$8402,$0008,$A8B5;
  764. FUNCTION SetEnvirons(verb: INTEGER;param: LONGINT): OSErr;
  765.     INLINE $2F3C,$8206,$000A,$A8B5;
  766. FUNCTION GetScript(script: INTEGER;verb: INTEGER): LONGINT;
  767.     INLINE $2F3C,$8404,$000C,$A8B5;
  768. FUNCTION SetScript(script: INTEGER;verb: INTEGER;param: LONGINT): OSErr;
  769.     INLINE $2F3C,$8208,$000E,$A8B5;
  770. FUNCTION CharByte(textBuf: Ptr;textOffset: INTEGER): INTEGER;
  771.     INLINE $2F3C,$8206,$0010,$A8B5;
  772. FUNCTION CharType(textBuf: Ptr;textOffset: INTEGER): INTEGER;
  773.     INLINE $2F3C,$8206,$0012,$A8B5;
  774. FUNCTION Pixel2Char(textBuf: Ptr;textLen: INTEGER;slop: INTEGER;pixelWidth: INTEGER;
  775.     VAR leadingEdge: BOOLEAN): INTEGER;
  776.     INLINE $2F3C,$820E,$0014,$A8B5;
  777. FUNCTION Char2Pixel(textBuf: Ptr;textLen: INTEGER;slop: INTEGER;offset: INTEGER;
  778.     direction: INTEGER): INTEGER;
  779.     INLINE $2F3C,$820C,$0016,$A8B5;
  780. FUNCTION Transliterate(srcHandle: Handle;dstHandle: Handle;target: INTEGER;
  781.     srcMask: LONGINT): OSErr;
  782.     INLINE $2F3C,$820E,$0018,$A8B5;
  783. PROCEDURE FindWord(textPtr: Ptr;textLength: INTEGER;offset: INTEGER;leadingEdge: BOOLEAN;
  784.     breaks: BreakTablePtr;VAR offsets: OffsetTable);
  785.     INLINE $2F3C,$8012,$001A,$A8B5;
  786. PROCEDURE HiliteText(textPtr: Ptr;textLength: INTEGER;firstOffset: INTEGER;
  787.     secondOffset: INTEGER;VAR offsets: OffsetTable);
  788.     INLINE $2F3C,$800E,$001C,$A8B5;
  789. PROCEDURE DrawJust(textPtr: Ptr;textLength: INTEGER;slop: INTEGER);
  790.     INLINE $2F3C,$8008,$001E,$A8B5;
  791. PROCEDURE MeasureJust(textPtr: Ptr;textLength: INTEGER;slop: INTEGER;charLocs: Ptr);
  792.     INLINE $2F3C,$800C,$0020,$A8B5;
  793. FUNCTION ParseTable(VAR table: CharByteTable): BOOLEAN;
  794.     INLINE $2F3C,$8204,$0022,$A8B5;
  795. FUNCTION GetDefFontSize: INTEGER;
  796.     INLINE $3EB8,$0BA8,$6604,$3EBC,$000C;
  797. FUNCTION GetSysFont: INTEGER;
  798.     INLINE $3EB8,$0BA6;
  799. FUNCTION GetAppFont: INTEGER;
  800.     INLINE $3EB8,$0984;
  801. FUNCTION GetMBarHeight: INTEGER;
  802.     INLINE $3EB8,$0BAA;
  803. FUNCTION GetSysJust: INTEGER;
  804.     INLINE $3EB8,$0BAC;
  805. PROCEDURE SetSysJust(newJust: INTEGER);
  806.     INLINE $31DF,$0BAC;
  807. PROCEDURE ReadLocation(VAR loc: MachineLocation);
  808.     INLINE $205F,$203C,$000C,$00E4,$A051;
  809. PROCEDURE WriteLocation(loc: MachineLocation);
  810.     INLINE $205F,$203C,$000C,$00E4,$A052;
  811. PROCEDURE UprText(textPtr: Ptr;len: INTEGER);
  812.     INLINE $301F,$205F,$A054;
  813. PROCEDURE LwrText(textPtr: Ptr;len: INTEGER);
  814.     INLINE $301F,$205F,$A056;
  815. FUNCTION StyledLineBreak(textPtr: Ptr;textLen: LONGINT;textStart: LONGINT;
  816.     textEnd: LONGINT;flags: LONGINT;VAR textWidth: Fixed;VAR textOffset: LONGINT): StyledLineBreakCode;
  817.     INLINE $2F3C,$821C,$FFFE,$A8B5;
  818. PROCEDURE GetFormatOrder(ordering: FormatOrderPtr;firstFormat: INTEGER;
  819.     lastFormat: INTEGER;lineRight: BOOLEAN;rlDirProc: Ptr;dirParam: Ptr);
  820.     INLINE $2F3C,$8012,$FFFC,$A8B5;
  821. FUNCTION IntlTokenize(tokenParam: TokenBlockPtr): TokenResults;
  822.     INLINE $2F3C,$8204,$FFFA,$A8B5;
  823. FUNCTION InitDateCache(theCache: DateCachePtr): OSErr;
  824.     INLINE $2F3C,$8204,$FFF8,$A8B5;
  825. FUNCTION String2Date(textPtr: Ptr;textLen: LONGINT;theCache: DateCachePtr;
  826.     VAR lengthUsed: LONGINT;VAR dateTime: LongDateRec): String2DateStatus;
  827.     INLINE $2F3C,$8214,$FFF6,$A8B5;
  828. FUNCTION String2Time(textPtr: Ptr;textLen: LONGINT;theCache: DateCachePtr;
  829.     VAR lengthUsed: LONGINT;VAR dateTime: LongDateRec): String2DateStatus;
  830.     INLINE $2F3C,$8214,$FFF4,$A8B5;
  831. PROCEDURE LongDate2Secs(lDate: LongDateRec;VAR lSecs: LongDateTime);
  832.     INLINE $2F3C,$8008,$FFF2,$A8B5;
  833. PROCEDURE LongSecs2Date(VAR lSecs: LongDateTime;VAR lDate: LongDateRec);
  834.     INLINE $2F3C,$8008,$FFF0,$A8B5;
  835. FUNCTION ToggleDate(VAR lSecs: LongDateTime;field: LongDateField;delta: DateDelta;
  836.     ch: INTEGER;params: TogglePB): ToggleResults;
  837.     INLINE $2F3C,$820E,$FFEE,$A8B5;
  838. FUNCTION Str2Format(inString: Str255;partsTable: NumberParts;VAR outString: NumFormatString): FormatStatus;
  839.     INLINE $2F3C,$820C,$FFEC,$A8B5;
  840. FUNCTION Format2Str(myCanonical: NumFormatString;partsTable: NumberParts;
  841.     VAR outString: Str255;VAR positions: TripleInt): FormatStatus;
  842.     INLINE $2F3C,$8210,$FFEA,$A8B5;
  843. FUNCTION FormatX2Str(x: Extended;myCanonical: NumFormatString;partsTable: NumberParts;
  844.     VAR outString: Str255): FormatStatus;
  845.     INLINE $2F3C,$8210,$FFE8,$A8B5;
  846. FUNCTION FormatStr2X(source: Str255;myCanonical: NumFormatString;partsTable: NumberParts;
  847.     VAR x: Extended): FormatStatus;
  848.     INLINE $2F3C,$8210,$FFE6,$A8B5;
  849. FUNCTION PortionText(textPtr: Ptr;textLen: LONGINT): Fixed;
  850.     INLINE $2F3C,$8408,$0024,$A8B5;
  851. FUNCTION FindScriptRun(textPtr: Ptr;textLen: LONGINT;VAR lenUsed: LONGINT): ScriptRunStatus;
  852.     INLINE $2F3C,$820C,$0026,$A8B5;
  853. FUNCTION VisibleLength(textPtr: Ptr;textLen: LONGINT): LONGINT;
  854.     INLINE $2F3C,$8408,$0028,$A8B5;
  855. FUNCTION ValidDate(VAR vDate: LongDateRec;flags: LONGINT;VAR newSecs: LongDateTime): INTEGER;
  856.     INLINE $2F3C,$8204,$FFE4,$A8B5;
  857. PROCEDURE IULDateString(VAR dateTime: LongDateTime;longFlag: DateForm;VAR result: Str255;
  858.     intlParam: Handle);
  859.     INLINE $3F3C,$0014,$A9ED;
  860. PROCEDURE IULTimeString(VAR dateTime: LongDateTime;wantSeconds: BOOLEAN;
  861.     VAR result: Str255;intlParam: Handle);
  862.     INLINE $3F3C,$0016,$A9ED;
  863.  
  864. {$ENDC}    { UsingScript }
  865.  
  866. {$IFC NOT UsingIncludes}
  867.     END.
  868. {$ENDC}
  869.  
  870.